{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "    感知机和神经网络\n",
    "    ~~~~~~~~~~\n",
    "\n",
    "    感知机模型\n",
    "\n",
    "    :copyright: (c) 2016 by the huaxz1986.\n",
    "    :license: lgpl-3.0, see LICENSE for more details.\n",
    "\"\"\"\n",
    "\n",
    "from matplotlib import  pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import numpy as np\n",
    "\n",
    "def creat_data(n):\n",
    "    '''\n",
    "    创建线性可分数据集\n",
    "\n",
    "    :param n: 正例样本的个数（同时也是负例样本的个数）\n",
    "    :return: 返回一个线性可分数据集，数据集大小为 2*n\n",
    "    '''\n",
    "    np.random.seed(1)\n",
    "    x_11=np.random.randint(0,100,(n,1)) # 第一组：第一维坐标值\n",
    "    x_12=np.random.randint(0,100,(n,1,))# 第一组：第二维坐标值\n",
    "    x_13=20+np.random.randint(0,10,(n,1,))#第一组： 第三维坐标值\n",
    "    x_21=np.random.randint(0,100,(n,1)) # 第二组：第一维坐标值\n",
    "    x_22=np.random.randint(0,100,(n,1)) # 第二组：第二维坐标值\n",
    "    x_23=10-np.random.randint(0,10,(n,1,)) # 第二组：第三维坐标值\n",
    "\n",
    "    new_x_12=x_12*np.sqrt(2)/2-x_13*np.sqrt(2)/2## 沿第一维轴旋转45度\n",
    "    new_x_13=x_12*np.sqrt(2)/2+x_13*np.sqrt(2)/2## 沿第一维轴旋转45度\n",
    "    new_x_22=x_22*np.sqrt(2)/2-x_23*np.sqrt(2)/2## 沿第一维轴旋转45度\n",
    "    new_x_23=x_22*np.sqrt(2)/2+x_23*np.sqrt(2)/2## 沿第一维轴旋转45度\n",
    "\n",
    "    plus_samples=np.hstack([x_11,new_x_12,new_x_13,np.ones((n,1))]) # 拼接成正例数据集\n",
    "    minus_samples=np.hstack([x_21,new_x_22,new_x_23,-np.ones((n,1))]) # 拼接成负例数据集\n",
    "    samples=np.vstack([plus_samples,minus_samples]) # 拼接成完整数据集\n",
    "    np.random.shuffle(samples)  # 混洗数据\n",
    "    return samples\n",
    "def creat_data_no_linear(n):\n",
    "    '''\n",
    "    创建线性不可分数据集\n",
    "\n",
    "    :param n: 正例样本的个数（同时也是负例样本的个数）\n",
    "    :return: 返回一个线性不可分数据集，数据集大小为 2*n\n",
    "    '''\n",
    "    np.random.seed(1)\n",
    "    x_11=np.random.randint(0,100,(n,1))# 第一组：第一维坐标值\n",
    "    x_12=np.random.randint(0,100,(n,1,))# 第一组：第二维坐标值\n",
    "    x_13=10+np.random.randint(0,10,(n,1,))#第一组： 第三维坐标值\n",
    "    x_21=np.random.randint(0,100,(n,1))# 第二组：第一维坐标值\n",
    "    x_22=np.random.randint(0,100,(n,1))# 第二组：第二维坐标值\n",
    "    x_23=20-np.random.randint(0,10,(n,1,)) # 第二组：第三维坐标值\n",
    "\n",
    "    new_x_12=x_12*np.sqrt(2)/2-x_13*np.sqrt(2)/2## 沿第一维轴旋转45度\n",
    "    new_x_13=x_12*np.sqrt(2)/2+x_13*np.sqrt(2)/2## 沿第一维轴旋转45度\n",
    "    new_x_22=x_22*np.sqrt(2)/2-x_23*np.sqrt(2)/2## 沿第一维轴旋转45度\n",
    "    new_x_23=x_22*np.sqrt(2)/2+x_23*np.sqrt(2)/2## 沿第一维轴旋转45度\n",
    "\n",
    "    plus_samples=np.hstack([x_11,new_x_12,new_x_13,np.ones((n,1))])# 拼接成正例数据集\n",
    "    minus_samples=np.hstack([x_21,new_x_22,new_x_23,-np.ones((n,1))])# 拼接成负例数据集\n",
    "    samples=np.vstack([plus_samples,minus_samples])# 拼接成完整数据集\n",
    "    np.random.shuffle(samples)  # 混洗数据\n",
    "    return samples\n",
    "def plot_samples(ax,samples):\n",
    "    '''\n",
    "    绘制样本点\n",
    "\n",
    "    :param ax: 绘制图形所在的 Axes\n",
    "    :param samples: 样本数据集\n",
    "    :return: None\n",
    "    '''\n",
    "    Y=samples[:,-1] # 标记信息\n",
    "    position_p=Y==1 ## 正类位置\n",
    "    position_m=Y==-1 ## 负类位置\n",
    "    ax.scatter(samples[position_p,0],samples[position_p,1],\n",
    "        samples[position_p,2],marker='+',label='+',color='b') # 绘制正类样本点\n",
    "    ax.scatter(samples[position_m,0],samples[position_m,1],\n",
    "        samples[position_m,2],marker='^',label='-',color='y') # 绘制负类样本点\n",
    "\n",
    "def run_plot_samples():\n",
    "    '''\n",
    "    绘制线性可分数据集\n",
    "\n",
    "    :return: None\n",
    "    '''\n",
    "    fig=plt.figure()\n",
    "    ax=Axes3D(fig)\n",
    "    data=creat_data(100) # 产生线性可分数据集\n",
    "    plot_samples(ax,data)\n",
    "    ax.legend(loc='best')\n",
    "    plt.show()\n",
    "\n",
    "def run_plot_samples_no_linear():\n",
    "    '''\n",
    "    绘制线性不可分数据集\n",
    "\n",
    "    :return: None\n",
    "    '''\n",
    "    data=creat_data_no_linear(100)# 产生线性不可分数据集\n",
    "    fig=plt.figure()\n",
    "    ax=Axes3D(fig)\n",
    "    plot_samples(ax,data)\n",
    "    ax.legend(loc='best')\n",
    "    plt.show()\n",
    "def perceptron(train_data,eta,w_0,b_0):\n",
    "     '''\n",
    "    感知机的原始算法\n",
    "\n",
    "    :param train_data: 训练数据集\n",
    "    :param eta: 学习率\n",
    "    :param w_0: 初始权重向量\n",
    "    :param b_0: 初始的 b\n",
    "    :return: 一个元组，依次为：最终的权重向量，最终的 b 值，迭代次数\n",
    "     '''\n",
    "     x=train_data[:,:-1]  # x 数据\n",
    "     y=train_data[:,-1]  #  对应的标记\n",
    "     length= train_data.shape[0] #样本集大小\n",
    "     w=w_0\n",
    "     b=b_0\n",
    "     step_num=0\n",
    "     while True:\n",
    "        i=0\n",
    "        while(i< length): ## 遍历一轮样本集中的所有的样本点\n",
    "            step_num+=1\n",
    "            '''\n",
    "          当应用于线性不可分数据集时，用下面4行代替上面的 step_num+=1 这一行。如果不这么做，那么当用于线性\n",
    "          不可分数据集时，迭代永远不会停止。\n",
    "            step_num+=1\n",
    "            if step_num>=10000000:\n",
    "                print(\"failed!,step_num =%d\"%step_num)\n",
    "                return\n",
    "          '''\n",
    "            x_i=x[i].reshape((x.shape[1],1)) # 变成列向量，因为需要执行 np.dot 函数\n",
    "            y_i=y[i]\n",
    "            if y_i*(np.dot(np.transpose(w),x_i)+b) <=0: # 该点是误分类点\n",
    "                w=w+eta*y_i*x_i  # 梯度下降\n",
    "                b=b+eta*y_i      # 梯度下降\n",
    "                break # 执行下一轮筛选\n",
    "            else:#该点不是误分类点，选取下一个样本点\n",
    "                i=i+1\n",
    "        if(i== length): #没有误分类点，结束循环\n",
    "            break\n",
    "     return (w,b,step_num)\n",
    "def creat_hyperplane(x,y,w,b):\n",
    "    '''\n",
    "    创建分离超平面\n",
    "\n",
    "    :param x: 分离超平面上的点的x坐标组成的数组\n",
    "    :param y: 分离超平面上的点的y坐标组成的数组\n",
    "    :param w: 超平面的法向量，它是一个列向量\n",
    "    :param b: 超平面的截距\n",
    "    :return: 分离超平面上的点的z坐标组成的数组\n",
    "    '''\n",
    "    return (-w[0][0]*x-w[1][0]*y-b)/w[2][0] # w0*x+w1*y+w2*z+b=0\n",
    "def run_perceptron():\n",
    "    '''\n",
    "    对线性可分数据集执行感知机的原始算法并绘制分离超平面\n",
    "\n",
    "    :return: None\n",
    "    '''\n",
    "    data=creat_data(100) #产生线性可分数据集\n",
    "    eta,w_0,b_0=0.1,np.ones((3,1),dtype=float),1 # 初始化 学习率、权重、 b\n",
    "    w,b,num=perceptron(data,eta,w_0,b_0) # 执行感知机的原始形式\n",
    "    ### 绘图\n",
    "    fig=plt.figure()\n",
    "    plt.suptitle(\"perceptron\")\n",
    "    ax=Axes3D(fig)\n",
    "\n",
    "    ### 绘制样本点\n",
    "    plot_samples(ax,data)\n",
    "\n",
    "    ##  绘制分离超平面\n",
    "    x=np.linspace(-30,100,100)  # 分离超平面的 x坐标数组\n",
    "    y=np.linspace(-30,100,100) # 分离超平面的 y坐标数组\n",
    "    x,y=np.meshgrid(x,y) # 划分网格\n",
    "    z=creat_hyperplane(x,y,w,b)  # 分离超平面的 z坐标数组\n",
    "    ax.plot_surface(x, y, z, rstride=1, cstride=1,color='g',alpha=0.2)\n",
    "\n",
    "    ax.legend(loc=\"best\")\n",
    "    plt.show()\n",
    "def run_perceptron_no_linear():\n",
    "    '''\n",
    "    对线性不可分数据集执行感知机的元素算法\n",
    "\n",
    "    :return: None\n",
    "    '''\n",
    "    data=creat_data_no_linear(100)#产生线性不可分数据集\n",
    "    perceptron(data,eta=0.1,w_0=np.zeros((2,1)),b_0=0)\n",
    "\n",
    "def creat_w(train_data,alpha):\n",
    "    '''\n",
    "    根据训练数据集和 alpha向量 创建 权重向量\n",
    "\n",
    "    :param train_data: 训练数据集\n",
    "    :param alpha: alpha 向量\n",
    "    :return: 权重向量\n",
    "    '''\n",
    "    x=train_data[:,:-1]  # x 数据\n",
    "    y=train_data[:,-1]  #  对应的分类\n",
    "    N= train_data.shape[0] #样本集大小\n",
    "    w=np.zeros((x.shape[1],1))\n",
    "    for i in range(0,N):\n",
    "        w=w+alpha[i][0]*y[i]*(x[i].reshape(x[i].size,1))\n",
    "    return w\n",
    "def perceptron_dual(train_data,eta,alpha_0,b_0):\n",
    "    '''\n",
    "    感知机的对偶形式算法\n",
    "\n",
    "    :param train_data: 训练数据集\n",
    "    :param eta: 学习率\n",
    "    :param alpha_0: 初始的 alpha 向量\n",
    "    :param b_0: 初始的 b 值\n",
    "    :return: 一个元组，依次为：最终的alpha 向量、最终的 b 值、迭代次数\n",
    "    '''\n",
    "    x=train_data[:,:-1]  # x 数据\n",
    "    y=train_data[:,-1]  #  对应的分类\n",
    "    length= train_data.shape[0] #样本集大小\n",
    "    alpha=alpha_0\n",
    "    b=b_0\n",
    "    step_num=0\n",
    "    while True:\n",
    "        i=0\n",
    "        while(i< length):\n",
    "            step_num+=1\n",
    "            x_i=x[i].reshape((x.shape[1],1)) # 变形为列向量，因为需要调用 np.dot\n",
    "            y_i=y[i]\n",
    "            w=creat_w(train_data,alpha)\n",
    "            z=y_i*(np.dot(np.transpose(w),x_i)+b)\n",
    "            if z <=0: # 该点是误分类点\n",
    "                alpha[i][0]+=eta  # 梯度下降\n",
    "                b+=eta*y_i  # 梯度下降\n",
    "                break # 梯度下降了，从头开始，执行下一轮筛选\n",
    "            else:\n",
    "                i=i+1 #该点不是误分类点，选取下一个样本点\n",
    "        if(i== length ): #没有误分类点，结束循环\n",
    "            break\n",
    "    return (alpha,b,step_num)\n",
    "def run_perceptron_dual():\n",
    "    '''\n",
    "    对线性可分数据集执行感知机的原始算法和对偶形式算法，并绘制分离超平面\n",
    "\n",
    "    :return: None\n",
    "    '''\n",
    "    data=creat_data(100)\n",
    "    eta,w_0,b_0=0.1,np.ones((3,1),dtype=float),1\n",
    "    w_1,b_1,num_1=perceptron(data,eta,w_0,b_0) ##执行原始形式的算法\n",
    "    alpha,b_2,num_2=perceptron_dual(data,eta=0.1,alpha_0=np.zeros((data.shape[0]*2,1)),\n",
    "        b_0=0) # 执行对偶形式的算法\n",
    "    w_2=creat_w(data,alpha)\n",
    "\n",
    "    print(\"w_1,b_1\",w_1,b_1)\n",
    "    print(\"w_2,b_2\",w_2,b_2)\n",
    "\n",
    "    ## 绘图\n",
    "    fig=plt.figure()\n",
    "    plt.suptitle(\"perceptron\")\n",
    "    ax=Axes3D(fig)\n",
    "\n",
    "    ### 绘制样本点\n",
    "    plot_samples(ax,data)\n",
    "\n",
    "    ##  绘制分离超平面\n",
    "    x=np.linspace(-30,100,100)  # 分离超平面的 x坐标数组\n",
    "    y=np.linspace(-30,100,100) # 分离超平面的 y坐标数组\n",
    "    x,y=np.meshgrid(x,y) # 划分网格\n",
    "    z=creat_hyperplane(x,y,w_1,b_1)  # 原始形式算法的分离超平面的 z坐标数组\n",
    "    z_2=creat_hyperplane(x,y,w_2,b_2)  # 对偶形式算法的分离超平面的 z坐标数组\n",
    "    ax.plot_surface(x, y, z, rstride=1, cstride=1,color='g',alpha=0.2)\n",
    "    ax.plot_surface(x, y, z_2, rstride=1, cstride=1,color='c',alpha=0.2)\n",
    "    ax.legend(loc=\"best\")\n",
    "    plt.show()\n",
    "def test_eta(data,ax,etas,w_0,alpha_0,b_0):\n",
    "        '''\n",
    "        测试学习率对于感知机两种形式算法的收敛速度的影响\n",
    "\n",
    "        :param data:  训练数据集\n",
    "        :param ax: Axes实例，负责绘制图形\n",
    "        :param etas: 候选的学习率的值组成的列表\n",
    "        :param w_0: 原始算法用到的初始权重向量\n",
    "        :param alpha_0: 对偶形式用到的初始 alpha 向量\n",
    "        :param b_0: 初始 b 值\n",
    "        :return: None\n",
    "        '''\n",
    "        nums1=[]\n",
    "        nums2=[]\n",
    "        for eta in etas:\n",
    "            _,_,num_1=perceptron(data,eta,w_0=w_0,b_0=b_0) # 获取原始形式算法的迭代次数\n",
    "            _,_,num_2=perceptron_dual(data,eta=0.1,alpha_0=alpha_0,b_0=b_0) # 获取对偶形式算法的迭代次数\n",
    "            nums1.append(num_1)\n",
    "            nums2.append(num_2)\n",
    "        ax.plot(etas,np.array(nums1),label='orignal iteraton times')\n",
    "        ax.plot(etas,np.array(nums2),label='dual iteraton times')\n",
    "def run_test_eta():\n",
    "    '''\n",
    "    执行 test_eta\n",
    "\n",
    "    :return: None\n",
    "    '''\n",
    "    fig=plt.figure()\n",
    "    fig.suptitle(\"perceptron\")\n",
    "    ax=fig.add_subplot(1,1,1)\n",
    "    ax.set_xlabel(r'$\\eta$')\n",
    "\n",
    "    data=creat_data(20) # 创建线性可分数据集\n",
    "    etas=np.linspace(0.01,1,num=25,endpoint=False)\n",
    "    w_0,b_0,alpha_0=np.ones((3,1)),0,np.zeros((data.shape[0],1))\n",
    "    test_eta(data,ax,etas,w_0,alpha_0,b_0)\n",
    "\n",
    "    ax.legend(loc=\"best\",framealpha=0.5)\n",
    "    plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__=='__main__':\n",
    "    run_plot_samples() # 执行 run_plot_samples\n",
    "    #run_perceptron()# 执行 run_perceptron\n",
    "    #run_perceptron_dual()# 执行 run_perceptron_dual\n",
    "    #run_test_eta()# 执行 run_test_eta\n",
    "    #run_plot_samples_no_linear()# 执行 run_plot_samples_no_linear\n",
    "    #run_perceptron_no_linear()# 执行 run_perceptron_no_linear"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
